package tesis.service.rest.impl;



import java.io.*;
import java.util.*;
import java.util.logging.Level;
import tesis.service.CrudService;

import tesis.service.TransactionalService;


import tesis.service.EnvioEmailService;
import javax.inject.Inject;
import javax.inject.Named;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import tesis.common.util.ConvertBeanUtil;
import tesis.common.util.MotorUtil;
import tesis.common.util.PropertyUtils;
import tesis.domain.*;
import tesis.dto.base.BaseRemoteOutBean;
import tesis.dto.in.ObjetoParametro;
import tesis.dto.in.*;
import tesis.dto.out.FormDTO;
import tesis.dto.util.Constantes;
import tesis.service.rest.MotorService;
import tesis.service.rest.WrapperResults;


public class MotorServiceImpl implements MotorService {
    private final static Logger LOG = LoggerFactory.getLogger(MotorServiceImpl.class);
    private final static String rutaDocumento = PropertyUtils.getAppProperty("ruta_archivos_server");

    @Inject
    @Named("crudService")
    CrudService crud;
    

    @Inject
    EnvioEmailService emailService;

    @Inject
    TransactionalService transactionalService;

  

    public BaseRemoteOutBean test(ObjetoParametro objeto) {
        System.out.println("------metodo REST 'test'------");
        System.out.println("id: " + objeto.getId());
        System.out.println("nombre: " + objeto.getNombre());
        //throw new UnsupportedOperationException("Not supported yet.");
        BaseRemoteOutBean respuesta = new BaseRemoteOutBean();
        respuesta.setMensaje("TEST");
        return respuesta;
    }

    public BaseRemoteOutBean test2(String  objeto){
        System.out.println("------metodo REST 'test2'------");
        System.out.println("objeto: " + objeto);
        List lst=crud.findByNamedQuery("Alarma.findAll");
        if (lst!=null){
            System.out.println("long: "+lst.size());
        }else{
            System.out.println("es nulo");
        }
        BaseRemoteOutBean respuesta = new BaseRemoteOutBean();
        respuesta.setMensaje("TEST2");
        return respuesta;
    }



    public ProcesoDTO saveProceso(ProcesoDTO procesoDTO) {
      ProcesoDTO beanOUT=new ProcesoDTO();
       Proceso entity=null;
       try{
          entity=ConvertBeanUtil.convertProcesoDTOtoEntity(procesoDTO);
          entity.setFechainstalacion(GregorianCalendar.getInstance().getTime());
          entity.setIndactivo('A');
          //entity = crud.create(entity);
          entity=transactionalService.instalarProceso(entity);
          beanOUT.setIdProceso(entity.getIdproceso());
          LOG.info("Registro correcto, id: "+beanOUT.getIdProceso());
       }catch(RuntimeException ex){
           LOG.error("Error: "+ex);
           beanOUT.setError(true);
           beanOUT.setMensaje("Error al insertar proceso; "+ex.getMessage());
           throw ex;
       }
       return beanOUT;
    }
    
    
    //Metodo probado
    public ProcesoDTO getProceso(Integer idProceso){
        ProcesoDTO bean=new ProcesoDTO();
        Proceso result=null;
        try{
            result= transactionalService.getProceso(idProceso);
            if (result!=null){
                if(result.getIdproceso() != null){
                    bean=ConvertBeanUtil.toProcesoDTO(result);
                    LOG.info("Proceso encontrado: "+bean.getNombre());
                }else{
                    LOG.info("Proceso no econtratado");
                }
            }else{
                LOG.info("Proceso no encontrado");
            }
        }catch(IllegalArgumentException  ex){
           LOG.info("Proceso no encontrado");
            
        }catch(RuntimeException ex){
            LOG.error("Error: "+ex);
            bean.setError(true);
            bean.setMensaje("Error al obtener proceso: "+ex.getMessage());
        }
        return bean;
    }
    
    //Metodo probado
    public InstanciaProcesoDTO getInstanceProcess(Integer codeInstanceStation){
        InstanciaProcesoDTO bean = new InstanciaProcesoDTO();
        InstanciaProceso result = null;
        try{
            result = transactionalService.getInstanciaProcesoByIdStation(codeInstanceStation);
            if(result != null){
               if(result.getIdinstanciaproceso() != null){
                   bean = ConvertBeanUtil.toInstanciaProcesoDTO(result);
               }else{
                    LOG.info("Instancia de estacion no encontrada");
               }
                
            }else{
                LOG.info("Codigo de instancia Estacion no encontrado");
            }  
         }catch(IllegalArgumentException  ex){
           LOG.info("Instancia de Estacion no encontrada");
        }
        catch(RuntimeException ex){
            LOG.error("Error: " +ex);
            LOG.info("Instancia de Estacion no encontrada");
       }
        return bean;
    } 
    //Metodo probado
    public InstanciaEstacionDTO getInstanceStation(Integer codeInstanceStation){
        InstanciaEstacionDTO bean = new InstanciaEstacionDTO();
        InstanciaEstacion result = null;
        try{          
            result = transactionalService.getInstanciaEstacion(codeInstanceStation);
            if(result !=null){
                if(result.getIdinstanciaestacion() == null){
                    bean.setError(true);
                    bean.setMensaje("Instancia no encontrada");
                }else{
                    bean = ConvertBeanUtil.toInstanciaEstacionDTO(result);
                }
            }
            else{
                bean.setError(true);
                bean.setMensaje("Error al obtener la instancia de la estacion");
            } 
        }catch(RuntimeException ex){
             LOG.error("Error: " +ex);
             bean.setError(true);
             bean.setMensaje("Error al obtener la instancia de la estacion: "+ex.getMessage());
        }
        return bean;
    }
    
    //Metodo probado
    public ListTipoDocumento getTypeDocuments(Integer codeStation){
        ListTipoDocumento lstResultBean = new ListTipoDocumento();
        List<TipoDocumentoDTO> lstBeans = new ArrayList<TipoDocumentoDTO>();
        List<TipoDocumento> lstResult = new ArrayList<TipoDocumento>();
        try{
            lstResult = transactionalService.getListaTipoDocumentos(codeStation);
            if(lstResult != null){
                
                if(lstResult.size()== 0){
                    LOG.info("Tipos documentos no encontrados");
                }
                else{
                    for(TipoDocumento tipoDocumento: lstResult){
                        lstBeans.add(ConvertBeanUtil.toTipoDocumentoDTO(tipoDocumento));
                    }
               
                }
            }
        }catch(RuntimeException ex){
            LOG.error("Error:  " + ex);
        }
        lstResultBean.setListTipoDocumentoDTO(lstBeans);
        return lstResultBean;
    }
    
      public ListTipoDocumento getTypeDocumentsInput(Integer codeStation){
       ListTipoDocumento lstResultBean = new ListTipoDocumento();
       List<TipoDocumentoDTO> lstBean = new ArrayList<TipoDocumentoDTO>();
       List<TipoDocumento> lstResult = new ArrayList<TipoDocumento>();
       Estacion  estacion = transactionalService.getEstacion(codeStation);
       ArrayList<ArrayList<Regla>> lstReglas = MotorUtil.ordenarReglas(estacion.getReglaList());
       Integer cantidadNiveles = lstReglas.size();
       ArrayList<Regla> reglas = lstReglas.get(0);  
       for(Regla regla:reglas){  
            List<ParametroDocumento> lstParDoc = MotorUtil.getParametroTipoDocumento(regla);
                 for(ParametroDocumento parDOC : lstParDoc){
                            if(MotorUtil.esEntrada(parDOC, regla) ){
                                lstResult.add(parDOC.getIdestaciontipodocumento().getIdtipodocumento());
                                
                            }
                 }
       }
       
       for(TipoDocumento e:lstResult) {
           lstBean.add(ConvertBeanUtil.toTipoDocumentoDTO(e));
       }
       lstResultBean.setListTipoDocumentoDTO(lstBean);
       
       return lstResultBean;
    }
    
        public ListTipoDocumento getTypeDocumentsOutput(Integer codeStation){
       ListTipoDocumento lstResultBean = new ListTipoDocumento();
        List<TipoDocumentoDTO> lstBean = new ArrayList<TipoDocumentoDTO>();
       List<TipoDocumento> lstResult = new ArrayList<TipoDocumento>();
       Estacion  estacion = transactionalService.getEstacion(codeStation);
       ArrayList<ArrayList<Regla>> lstReglas = MotorUtil.ordenarReglas(estacion.getReglaList());
       Integer cantidadNiveles = lstReglas.size();
       ArrayList<Regla> reglas = lstReglas.get(cantidadNiveles-1);  
       for(Regla regla:reglas){  
            List<ParametroDocumento> lstParDoc = MotorUtil.getParametroTipoDocumento(regla);
                 for(ParametroDocumento parDOC : lstParDoc){
                            if(MotorUtil.esSalida(parDOC, regla) ){
                                lstResult.add(parDOC.getIdestaciontipodocumento().getIdtipodocumento());
                                
                            }
                 }
       }
       
       for(TipoDocumento e:lstResult) {
           lstBean.add(ConvertBeanUtil.toTipoDocumentoDTO(e));
       }
       lstResultBean.setListTipoDocumentoDTO(lstBean);
       
       return lstResultBean;
    }
    
    
    
    
    //Metodo probado
    public ListVariables getVars( Integer codeStation){
       ListVariables lstResultBean = new ListVariables();
        List<VariableDTO> lstBean = new ArrayList<VariableDTO>();
        List<Variable> lstResult = new ArrayList<Variable>();
        try{
            lstResult = transactionalService.getListaVariables(codeStation);
            if(lstResult != null){
                if(lstResult.size() == 0){
                    LOG.info("Variables no encontradas");
                }else{
                    for(Variable e: lstResult){     
                        lstBean.add(ConvertBeanUtil.toVariableDTO(e));
                   }
                }
            }
                
        }catch(RuntimeException ex){
            LOG.error("Error: "  + ex);
        }  
        lstResultBean.setListVariableDTO(lstBean);
        return lstResultBean;
    }
    
    
      public ListVariables getVarsInput( Integer codeStation){
       ListVariables lstResultBean = new ListVariables();
           List<VariableDTO> lstBean = new ArrayList<VariableDTO>();
       List<Variable> lstResult = new ArrayList<Variable>();
       Estacion  estacion = transactionalService.getEstacion(codeStation);
       ArrayList<ArrayList<Regla>> lstReglas = MotorUtil.ordenarReglas(estacion.getReglaList());
       Integer cantidadNiveles = lstReglas.size();
       ArrayList<Regla> reglas = lstReglas.get(0);  
       for(Regla regla:reglas){  
            List<ParametroVariable> lstParVar = MotorUtil.getParametroVariable(regla);
                 for(ParametroVariable parVar : lstParVar){
                            if(MotorUtil.esEntrada(parVar, regla) ){
                                lstResult.add(parVar.getIdestacionvariable().getIdvariable());
                                
                            }
                 }
       }
       
       for(Variable e:lstResult) {
           lstBean.add(ConvertBeanUtil.toVariableDTO(e));
       }
       lstResultBean.setListVariableDTO(lstBean);
       
       return lstResultBean;
    }
    
      
    public ListVariables getVarsOutput( Integer codeStation){
       ListVariables lstResultBean = new ListVariables();
       List<VariableDTO> lstBean = new ArrayList<VariableDTO>();
       List<Variable> lstResult = new ArrayList<Variable>();
       Estacion  estacion = transactionalService.getEstacion(codeStation);
       ArrayList<ArrayList<Regla>> lstReglas = MotorUtil.ordenarReglas(estacion.getReglaList());
       Integer cantidadNiveles = lstReglas.size();
       ArrayList<Regla> reglas = lstReglas.get(cantidadNiveles-1);  
       for(Regla regla:reglas){  
            List<ParametroVariable> lstParVar = MotorUtil.getParametroVariable(regla);
                 for(ParametroVariable parVar : lstParVar){
                            if(MotorUtil.esSalida(parVar, regla) ){
                                lstResult.add(parVar.getIdestacionvariable().getIdvariable());
                                
                            }
                 }
       }
       
       for(Variable e:lstResult) {
           lstBean.add(ConvertBeanUtil.toVariableDTO(e));
       }
       lstResultBean.setListVariableDTO(lstBean);
       
       return lstResultBean;
    }  
      
      
      
      
   
    //Metodo probado
    public EstacionDTO getStation(Integer idProceso,String nameStation){
        EstacionDTO bean = new EstacionDTO();
        Estacion result = null;
        try{
            nameStation=nameStation.replace("_"," ");
            result = transactionalService.getEstacion(idProceso,nameStation);
            if(result != null){
                if(result.getIdcargo()==null){
                    LOG.info("Estacion no encontrada");
                }else{
                    bean = ConvertBeanUtil.toEstacionDTO(result);
                }
            }else{
                bean.setError(true);
                bean.setMensaje("Error al obtener la estacion");
            }
        }catch(RuntimeException ex){
            LOG.error("Error: " + ex);
            bean.setError(true);
            bean.setMensaje("Error al obtener la estacion: " + ex.getMessage());
        }        
        return bean;
        
    }
    
        public CargoDTO getOfficeInstanceStation(Integer codeInstanceStation){
         CargoDTO bean = new CargoDTO();
         Cargo result = null;
         try{
             result = transactionalService.getCargo(codeInstanceStation);
             if(result!= null){
                 bean = ConvertBeanUtil.toCargoDTO(result);
                 LOG.info("Cargo Encontrado: " + bean.getNombre());
             }else{
                 LOG.info("Cargo no encontrado");
                 bean.setError(true);
                 bean.setMensaje("Cargo no encontrado");
             }
          
         }catch(RuntimeException ex){
             LOG.error("Error: " +ex);
             bean.setError(true);
             bean.setMensaje("Error al obtener el cargo: "+ex.getMessage());
         }
         
         InstanciaEstacion e = new InstanciaEstacion();
         e.getInstanciaEstacionXParametroVariableList().get(0).getIdparamentrovariable().getIdestacionvariable().getIdvariable();
         
         return bean;
     }
        
     public ListVariables getValoresVariables(Integer idInstnacia){
         ListVariables result = new ListVariables();
         InstanciaEstacion instanciaEstacion = transactionalService.getInstanciaEstacion(idInstnacia);
         
         
         
         return result;
     }   
        
        
     public ListInstanciaEstacionDTO getInstanceStationbyUser(  AplicacionClienteDTO aplicacionClienteDTO){
         
         LOG.info("entrando al metodo con el estado "+ aplicacionClienteDTO.getNombreEstadoEstacion());     
         List<InstanciaEstacionDTO> lstResult = new ArrayList<InstanciaEstacionDTO>();
         List<InstanciaEstacion> lstDomain = null;
         ListInstanciaEstacionDTO result = new ListInstanciaEstacionDTO();
         WrapperResults resultados=null;
         try{
             EstadoInstanciaEstacion estadoInstanciaEstacion = transactionalService.getEstadoInstanciaEstacion(aplicacionClienteDTO.getNombreEstadoEstacion()) ;
             EstadoInstanciaEstacionDTO estadoInstEstDTO = ConvertBeanUtil.toEstadoInstanciaEstacionDTO(estadoInstanciaEstacion);
         
             resultados=transactionalService.getInstanciaEstacionByUser(aplicacionClienteDTO);
             lstDomain=resultados.getListaResultados();
             InstanciaEstacionDTO bean =null;
             for(InstanciaEstacion e:lstDomain){
                //EstadoInstanciaEstacionXInstanciaEstacion instaEst =  transactionalService.getEstadoInstanciaEstacion(e);
                //if (instaEst.getIdestadoinstanciaestacion()!=null){
                    //if(estadoInstanciaEstacion.getIdestadoinstanciaestacion().intValue() == instaEst.getIdestadoinstanciaestacion().getIdestadoinstanciaestacion().intValue()){
                        bean = ConvertBeanUtil.toInstanciaEstacionDTO(e);
                        bean.setEstadoDTO(estadoInstEstDTO);
                        lstResult.add(bean);
                    //}
                //}
             }    
         }catch(RuntimeException ex){
             LOG.error("Error al obtener las insntacias de un estacion");
         }
         
         result.setLstInstanciaEstacionDTO(lstResult);
         result.setCantidadTotal(resultados.getCantidadTotal());
         return result;    
     }   
        
        
     public ListEstadoInstanciaEstacionDTO getStateInstanceStation(){
         ListEstadoInstanciaEstacionDTO result = new ListEstadoInstanciaEstacionDTO();
         List<EstadoInstanciaEstacion> lstResult = transactionalService.getEstadoInstanciaEstacion();
         List<EstadoInstanciaEstacionDTO> lstResultDTO = new ArrayList<EstadoInstanciaEstacionDTO>();
                 
         try{
             for(EstadoInstanciaEstacion e: lstResult){
              lstResultDTO.add(ConvertBeanUtil.toEstadoInstanciaEstacionDTO(e));   
             }
             result.setLstEstadoInstanciaEstacionDTO(lstResultDTO);
             
         }catch(RuntimeException ex){
             LOG.error("Error al obtener los estado de las instancias de estacion: " + ex);
             result.setError(true);
             result.setMensaje("Error :" + ex.getMessage());
         }        
          return result;
     }
     
     
    public ListProcesoDTO getAssignProcessUser(Integer idUser,Integer inicio, Integer fin){
        ListProcesoDTO result = new ListProcesoDTO();
        List<ProcesoDTO> lstResult = new ArrayList<ProcesoDTO>();
        List<Estacion> lstEstacion = new ArrayList<Estacion>();
        WrapperResults resultadosWrapper=null;
        Cargo cargo = transactionalService.getCargoByUser(idUser);
        try{
            resultadosWrapper = transactionalService.getEstacionbyCargo(cargo.getIdcargo(),inicio,fin);
            lstEstacion=resultadosWrapper.getListaResultados();
            for(Estacion e:lstEstacion){
                if(MotorUtil.esPrimeraEstacion(e)){
                    ProcesoDTO proceso = ConvertBeanUtil.toProcesoLightDTO(e.getIdproceso());
                    lstResult.add(proceso);
                }
            }
            
        }catch(RuntimeException ex){
            LOG.error("Error al obtener procesos instanciables por el usuario: " + ex );
        }
        
        result.setLstProceso(lstResult);
        result.setCantidadTotal(lstResult.size());
        
        return result;
    }
     
    

          
      public InstanciaEstacionDTO getFirstInstanceStation(Integer idProceso){
          InstanciaEstacionDTO instanciaEst = new InstanciaEstacionDTO();
          Proceso proceso = transactionalService.getProceso(idProceso);
          Estacion estacion = null;
          for(Estacion e:proceso.getEstacionList()){
              if(MotorUtil.esPrimeraEstacion(e)){
                  estacion = e;
                  break;
              }
          }
          InstanciaProcesoDTO instanciaProcesoDTO = new InstanciaProcesoDTO();
          instanciaProcesoDTO.setIdproceso(idProceso);
          instanciaProcesoDTO.setIndactivo(Constantes.ACTIVO.charAt(0));
         
          
          instanciaEst.setUrl(estacion.getDireccionformulario());
          instanciaEst.setNombreEstacion(estacion.getNombre());             
          instanciaEst.setInstanciaProceso(instanciaProcesoDTO);
          
          return instanciaEst;
      }
      
      public InstanciaEstacionDTO createInstanciaEstacion(InstanciaEstacionDTO instancia){
          InstanciaEstacion instanciaEstacion = new InstanciaEstacion();
          instanciaEstacion.setIdinstanciaestacion(instancia.getIdinstanciaestacion());
          instanciaEstacion.setFechacreacion(new Date());
          instanciaEstacion.setFechatermino(new Date());
          instancia.setNombreEstacion(instancia.getNombreEstacion().replace("_", " "));
          instanciaEstacion.setIdestacion(new Estacion(transactionalService.getEstacion(instancia.getInstanciaProceso().getIdproceso(),instancia.getNombreEstacion()).getIdestacion()));
          instanciaEstacion.setIdinstanciaproceso(new InstanciaProceso(instancia.getInstanciaProceso().getIdinstanciaproceso()));
          instanciaEstacion.setIdusuario(new Usuario(instancia.getUsuario().getIdusuario()));
          
          instanciaEstacion = transactionalService.createInstanceEstacion(instanciaEstacion);
          
          EstadoInstanciaEstacionXInstanciaEstacion estXIns = new EstadoInstanciaEstacionXInstanciaEstacion();
          estXIns.setIdinstanciaestacion(instanciaEstacion);
          estXIns.setIdestadoinstanciaestacion(transactionalService.getEstadoInstanciaEstacion(Constantes.Instancia_Estacion_INICIADA));
          estXIns.setFecha(new Date());
          estXIns = transactionalService.saveEstInstXInstEst(estXIns);
          
          instancia.setIdinstanciaestacion(instanciaEstacion.getIdinstanciaestacion());
          
          return instancia;
      }
    
    
      public InstanciaProcesoDTO createInstanciaProceso(InstanciaProcesoDTO instancia){
          InstanciaProceso instanciaProceso = new InstanciaProceso();
          instanciaProceso.setFechacreacion(new Date());
          instanciaProceso.setFechatermino(new Date());
          instanciaProceso.setIdproceso(new Proceso(instancia.getIdproceso().intValue()));
          instanciaProceso.setIndactivo(Constantes.ACTIVO.charAt(0));
          instanciaProceso.setIdinstanciaproceso(instancia.getIdinstanciaproceso());
          instanciaProceso = transactionalService.createInstanceProceso(instanciaProceso);
          
          InstanciaProcesoXEstadoInstanciaProceso instXEst = new InstanciaProcesoXEstadoInstanciaProceso();
          instXEst.setFecha(new Date());
          instXEst.setIdinstanciaproceso(instanciaProceso);
          instXEst.setIdestadoinstanciaproceso(transactionalService.getEstadoInstanciaProceso(Constantes.Instancia_Proceso_INSTANCIADO));
          
          instXEst = transactionalService.saveInstProXEstInstPro(instXEst);
          
          
          instancia.setIdinstanciaproceso(instanciaProceso.getIdinstanciaproceso());
          
          return instancia;
      } 
     
      public Expediente createExpediente(InstanciaProcesoDTO instanciaProcesoDTO){
          Expediente bean = new Expediente();
         bean.setCodigoexpediente(instanciaProcesoDTO.getIdinstanciaproceso().toString());
         bean.setFechacreacion(new Date());
         bean.setIdinstanciaproceso(new InstanciaProceso(instanciaProcesoDTO.getIdinstanciaproceso()));
         bean = transactionalService.saveExpediente(bean);
          return bean;
      } 
      
      
        
      public ExecuteStationDTO executeStation(ExecuteStationDTO executeStationDTO){
            
          //si se pasan los ids, se actualizan las entidades
            InstanciaProcesoDTO instanciaProcesoDTO= createInstanciaProceso(executeStationDTO.getInstanciaProcesoDTO());
            executeStationDTO.getInstanciaDTO().setInstanciaProceso(instanciaProcesoDTO);
            InstanciaEstacionDTO instanciaEstacionDTO = createInstanciaEstacion(executeStationDTO.getInstanciaDTO());
            executeStationDTO.setInstanciaDTO(instanciaEstacionDTO);
        
          if(executeStationDTO.getInstanciaDTO().getIdinstanciaestacion() == null){
              Expediente expediente = createExpediente(executeStationDTO.getInstanciaProcesoDTO());
          }
              
          //InstanciaEstacionDTO bean = new InstanciaEstacionDTO();          
          Estacion estacion = transactionalService.getEstacion(executeStationDTO.getInstanciaProcesoDTO().getIdproceso(),executeStationDTO.getInstanciaDTO().getNombreEstacion());//modificar para que primero busqe por procesos y luego por estacion
          InstanciaEstacion instEstProcesada = transactionalService.getInstanciaEstacion(executeStationDTO.getInstanciaDTO().getIdinstanciaestacion());
          EstadoInstanciaEstacionXInstanciaEstacion estadoInstancia = transactionalService.getEstadoInstanciaEstacion(instEstProcesada);
          InstanciaProceso instanciaProceso = instEstProcesada.getIdinstanciaproceso();
          Expediente expediente = transactionalService.getExpediente(instanciaProceso.getIdinstanciaproceso());
          
          for(DocumentoDTO documentoDTO:executeStationDTO.getLstDocumentoDTO()){
              // se guarda los archivo 
                
                Documento documento = ConvertBeanUtil.convertDocumentoDTOtoEntity(documentoDTO);    
                documento.setIdexpediente(expediente);
                documento.setDescripcion("");
                documento.setIdtipodocumento(new TipoDocumento(documentoDTO.getIdtipodocumentoDTO().getIdTipoDocumento()));
                documento.setIndactivo(Constantes.ACTIVO.charAt(0));
                documento.setNombre(documentoDTO.getNombre());
               // documento.setRutadocumento(documentoDTO.getRutadocumento());
                documento.setRutadocumento(rutaDocumento);
                documento = transactionalService.saveDocumento(documento);
                //se necesita el id para el instancia parametro documento
                documentoDTO.setIddocumento(documento.getIddocumento());
                
                
                File file  = documentoDTO.getFile();
                File archivo = new File(rutaDocumento+"/"+documento.getNombre() + "_" + documento.getIddocumento().toString());
                
                int i = 0;
                try {
                  // archivo.createNewFile();
                    archivo.setWritable(true);
                    
                    FileInputStream leido = new FileInputStream(file);
                    FileOutputStream streamArchivo = new FileOutputStream(archivo);
                     int lector = 1;
                     while(lector != -1){
                         lector = leido.read();
                          streamArchivo.write(lector);
                     }  
                    //FileOutputStream streamArchivo = new FileOutputStream(archivo);
                                     
                   streamArchivo.close();
                    
                } catch (IOException ex) {
                    java.util.logging.Logger.getLogger(MotorServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
             }      
          }
          
          boolean resultExecution = true;
          boolean estAltActivas = false;
          Regla UltimaRegla = null;
          try{
                ArrayList<ArrayList<Regla>> lstReglas = MotorUtil.ordenarReglas(estacion.getReglaList());
                Integer cantidadNiveles = lstReglas.size();
                for(Integer i = 0 ; i<cantidadNiveles;i++){
                    for(Regla regla:lstReglas.get(i)){  
                        boolean resultAnalisis = true;                        
                        // Se procesan las entradas
                        List<ParametroVariable> lstParVar = MotorUtil.getParametroVariable(regla);
                        for(ParametroVariable parVar : lstParVar){
                            if(MotorUtil.esEntrada(parVar, regla) && MotorUtil.deberiaAnalizarse(parVar, resultExecution) ){
                                
                               boolean respAnalisisVar =  MotorUtil.analizarVariable(parVar, executeStationDTO.getLstVarDTO());
                               resultAnalisis = MotorUtil.analizarRegla(resultAnalisis, respAnalisisVar, regla);
                               
                               InstanciaEstacionXParametroVariable resp = MotorUtil.getInsEstXParVar(parVar, executeStationDTO,regla);
                               resp = transactionalService.saveInstEstXParVar(resp);
                               HistoricoParametroVariable hParVar = new HistoricoParametroVariable();
                               hParVar.setFechamodificacion(new Date());
                               hParVar.setIdestacionparametrovariable(resp);
                               hParVar.setIdestadoinstancia(estadoInstancia);
                               hParVar.setValorvariable(resp.getValorvariable());
                               transactionalService.saveHistoricoParametroVariable(hParVar);
                               
                               
                               
                            }
                        }
                        
                        List<ParametroDocumento> lstParDoc = MotorUtil.getParametroTipoDocumento(regla);
                        for(ParametroDocumento parDoc : lstParDoc){
                            if(MotorUtil.esEntrada(parDoc, regla)&& MotorUtil.deberiaAnalizarse(parDoc, resultExecution)){
                                boolean respAnalisisTDoc = MotorUtil.analizarDocumento(parDoc,executeStationDTO.getLstDocumentoDTO());
                                resultAnalisis = MotorUtil.analizarRegla(resultAnalisis, respAnalisisTDoc, regla); 
                                
                                InstanciaEstacionXParametroDocumento resp= MotorUtil.getInstEstXParDoc(parDoc, executeStationDTO, regla);
                                resp =transactionalService.saveInstEstXParDoc(resp);
                                HistoricoParametroDocumento hParDoc = new HistoricoParametroDocumento();
                                hParDoc.setFechamodificacion(new Date());
                                hParDoc.setIdestacionparemetrodocumento(resp);
                                hParDoc.setIdestadoinstancia(estadoInstancia);
                                hParDoc.setIdestadodocumento(resp.getIdestadodocumento());
                                transactionalService.saveHistoricoParametroDocumento(hParDoc);
                                
                                
                            }
                        }
                        //Cuando se proceso con los dtos, estos deben cambiar a ese valor para que luego sigan siendo utilizados
                        //en caso se utilizan como entradas de otras reglas
                        // se procesan las salidas    
                        for(ParametroVariable parVar:lstParVar){
                            if(MotorUtil.esSalida(parVar, regla)){
                                if(resultAnalisis == true && parVar.getEsverdadera()=='Y' ){
                                   InstanciaEstacionXParametroVariable resp = MotorUtil.getInsEstXParVar(parVar, executeStationDTO,regla);
                                    resp = transactionalService.saveInstEstXParVar(resp);
                                    HistoricoParametroVariable hParVar = new HistoricoParametroVariable();
                                    hParVar.setFechamodificacion(new Date());
                                    hParVar.setIdestacionparametrovariable(resp);
                                    hParVar.setIdestadoinstancia(estadoInstancia);
                                    hParVar.setValorvariable(parVar.getValoractualizado());
                                    transactionalService.saveHistoricoParametroVariable(hParVar);
                                }
                                if(resultAnalisis == false && parVar.getEsverdadera()=='N'){ 
                                    InstanciaEstacionXParametroVariable resp = MotorUtil.getInsEstXParVar(parVar, executeStationDTO,regla);
                                    resp = transactionalService.saveInstEstXParVar(resp);
                                    HistoricoParametroVariable hParVar = new HistoricoParametroVariable();
                                    hParVar.setFechamodificacion(new Date());
                                    hParVar.setIdestacionparametrovariable(resp);
                                    hParVar.setIdestadoinstancia(estadoInstancia);
                                    hParVar.setValorvariable(parVar.getValoractualizado()); 
                                    transactionalService.saveHistoricoParametroVariable(hParVar);
                                }
                            }
                        }
                        
                        for(ParametroDocumento parDoc: lstParDoc){
                            if(MotorUtil.esSalida(parDoc, regla)){
                                if(resultAnalisis == true && parDoc.getEsverdadera() == 'Y' ){
                                    InstanciaEstacionXParametroDocumento resp= MotorUtil.getInstEstXParDoc(parDoc, executeStationDTO,regla);
                                    resp =transactionalService.saveInstEstXParDoc(resp);
                                    HistoricoParametroDocumento hParDoc = new HistoricoParametroDocumento();
                                    hParDoc.setFechamodificacion(new Date());
                                    hParDoc.setIdestacionparemetrodocumento(resp);
                                    hParDoc.setIdestadoinstancia(estadoInstancia);
                                    hParDoc.setIdestadodocumento(parDoc.getValoractualizado());
                                    transactionalService.saveHistoricoParametroDocumento(hParDoc);
                                    
                                }
                                if(resultAnalisis == false && parDoc.getEsverdadera() == 'N'){ 
                                    InstanciaEstacionXParametroDocumento resp = MotorUtil.getInstEstXParDoc(parDoc, executeStationDTO,regla);
                                    resp = transactionalService.saveInstEstXParDoc(resp);
                                    HistoricoParametroDocumento hParDoc = new HistoricoParametroDocumento();
                                    hParDoc.setFechamodificacion(new Date());
                                    hParDoc.setIdestacionparemetrodocumento(resp);
                                    hParDoc.setIdestadoinstancia(estadoInstancia);
                                    hParDoc.setIdestadodocumento(parDoc.getValoractualizado());
                                    transactionalService.saveHistoricoParametroDocumento(hParDoc);
                                }
                            }
                        }
                        
                        resultExecution = resultAnalisis;
                        UltimaRegla = regla;
                    }
                }

               // InstanciaProceso instanciaProceso = instEstProcesada.getIdinstanciaproceso();            
                
                        if(MotorUtil.existenConexionesAlternas(UltimaRegla)){
                            List<ConexionEstacionregla> lstConexionRegla = UltimaRegla.getConexionEstacionreglaList();
                            for(ConexionEstacionregla e: lstConexionRegla){
                                if(resultExecution == true && e.getEsverdadera() == 'Y'){
                                    estAltActivas = true;
                                    
                                    InstanciaEstacion instEstAlter = MotorUtil.getInstEstAlt(e,executeStationDTO,instanciaProceso);
                                    Usuario usuario = transactionalService.asignarUsuario(instEstAlter.getIdestacion().getIdcargo());
                                    instEstAlter.setIdusuario(usuario);
                                    transactionalService.saveInstanciaEstacion(instEstAlter);
                                    
                                        
                                }
                                if(resultExecution == false && e.getEsverdadera() == 'N'){
                                    estAltActivas = true;
                                    InstanciaEstacion instEstAlter = MotorUtil.getInstEstAlt(e,executeStationDTO,instanciaProceso);
                                    instEstAlter = transactionalService.saveInstanciaEstacion(instEstAlter);
                                    
                                    EstadoInstanciaEstacion estInst = transactionalService.getEstadoInstanciaEstacion(Constantes.Instancia_Estacion_INICIADA);
                                    EstadoInstanciaEstacionXInstanciaEstacion estInsXEstInstNew = new EstadoInstanciaEstacionXInstanciaEstacion();
                                    estInsXEstInstNew.setFecha(new Date());
                                    estInsXEstInstNew.setIdestadoinstanciaestacion(estInst);
                                    estInsXEstInstNew.setIdinstanciaestacion(instEstAlter);
                                    transactionalService.saveEstInstXInstEst(estInsXEstInstNew);
                                }
                            }
                            
                        }
                        
                       if(estAltActivas == false ){
                                if(MotorUtil.esUltimaEstacion(estacion)){
                                    InstanciaProceso instProceso = transactionalService.getInstanciaProcesoByIdStation(executeStationDTO.getInstanciaDTO().getIdinstanciaestacion());
                                    instProceso.setFechatermino(new Date());
                                    instProceso.setIndactivo('N');
                                    transactionalService.updateInstanciaProceso(instProceso);
                                    
                                    EstadoInstanciaProceso estInstPro = transactionalService.getEstadoInstanciaProceso(Constantes.Instancia_Proceso_TERMINADO);
                                    InstanciaProcesoXEstadoInstanciaProceso instProXEstInsPro = new InstanciaProcesoXEstadoInstanciaProceso();
                                    instProXEstInsPro.setFecha(new Date());
                                    instProXEstInsPro.setIdestadoinstanciaproceso(estInstPro);
                                    instProXEstInsPro.setIdinstanciaproceso(instanciaProceso);
                                    transactionalService.saveInstProXEstInstPro(instProXEstInsPro);
                                    executeStationDTO.getInstanciaProcesoDTO().setFechatermino(new Date());     
                                }else{
                                    
                                    InstanciaEstacion instEstacion = new InstanciaEstacion();
                            
                                    instEstacion.setFechacreacion(new Date());
                                    instEstacion.setFechatermino(new Date());
                                    instEstacion.setIdestacion(MotorUtil.obtenerSiguienteEstacion(estacion));
                                    instEstacion.setIdusuario(new Usuario(executeStationDTO.getInstanciaDTO().getUsuario().getIdusuario()));
                                    instEstacion.setIdinstanciaproceso(instanciaProceso);
                                    Usuario usuario = transactionalService.asignarUsuario(instEstacion.getIdestacion().getIdcargo());
                                    instEstacion.setIdusuario(usuario);
                                    instEstacion = transactionalService.saveInstanciaEstacion(instEstacion);
                                    
                                    EstadoInstanciaEstacion estInst = transactionalService.getEstadoInstanciaEstacion(Constantes.Instancia_Estacion_INICIADA);
                                    EstadoInstanciaEstacionXInstanciaEstacion estInsXEstInstNew = new EstadoInstanciaEstacionXInstanciaEstacion();
                                      estInsXEstInstNew.setFecha(new Date());
                                    estInsXEstInstNew.setIdestadoinstanciaestacion(estInst);
                                    estInsXEstInstNew.setIdinstanciaestacion(instEstacion);
                                    transactionalService.saveEstInstXInstEst(estInsXEstInstNew);
                                }                           
                         
                         }
                         
                       
                
                instEstProcesada.setFechatermino(new Date());
                transactionalService.updateInstanciaEstacion(instEstProcesada);              
                
                EstadoInstanciaEstacion estInst = transactionalService.getEstadoInstanciaEstacion(Constantes.Instancia_Estacion_PROCESADA);
                EstadoInstanciaEstacionXInstanciaEstacion estInsXEstInst = new EstadoInstanciaEstacionXInstanciaEstacion();
                estInsXEstInst.setFecha(new Date());
                estInsXEstInst.setIdestadoinstanciaestacion(estInst);
                estInsXEstInst.setIdinstanciaestacion(instEstProcesada);
                transactionalService.saveEstInstXInstEst(estInsXEstInst);
                
          }catch(RuntimeException ex){
              LOG.error("error: "+ex);
              executeStationDTO.setError(true);
              executeStationDTO.setMensaje("Error al procesar la estacion " + executeStationDTO.getInstanciaDTO().getNombreEstacion() + " Error: " + ex.getMessage());
              throw  ex;
          }
          return executeStationDTO;
      }  
        
      

      
      
      
        
      public  ListInstanciaEstacionDTO pruebaEjecucion(Integer a){
//        ExecuteStationDTO prueba = new ExecuteStationDTO();
//        InstanciaEstacionDTO  instancia= new InstanciaEstacionDTO();
//        UsuarioDTO usuario = new UsuarioDTO();
//        usuario.setIdusuario(1);
//        instancia.setUsuario(usuario);
//        instancia.setNombreEstacion("EST 1");
//        instancia.setIdinstanciaestacion(2);
//        VariableDTO varDTO = new VariableDTO();
//        varDTO.setIdvariable(2);
//        varDTO.setValorVariable("500");
//        varDTO.setTipoDatoDTO(new TipoDatoDTO(5));
//
//        DocumentoDTO docDTO = new DocumentoDTO();
//        docDTO.setIddocumento(1);
//        TipoDocumentoDTO tipo = new TipoDocumentoDTO();
//        EstadoDocumentoDTO est = new EstadoDocumentoDTO();
//        est.setIdestadodocumento(1);
//        tipo.setIdTipoDocumento(1);
//        tipo.setEstadoDocumento(est);
//        docDTO.setIdtipodocumentoDTO(tipo);
//
//        List<VariableDTO> lstVar = new ArrayList<VariableDTO>();
//        lstVar.add(varDTO);
//        List<DocumentoDTO> lstDoc = new ArrayList<DocumentoDTO>();
//        lstDoc.add(docDTO);
//
//        prueba.setLstDocumentoDTO(lstDoc);
//        prueba.setLstVarDTO(lstVar);
//        prueba.setInstanciaDTO(instancia);
          
          
          
//          
//          ExecuteStationDTO prueba = new ExecuteStationDTO();
//          InstanciaEstacionDTO  instancia= new InstanciaEstacionDTO();
//          UsuarioDTO usuario = new UsuarioDTO();
//          usuario.setIdusuario(1);
//          instancia.setUsuario(usuario);
//          instancia.setNombreEstacion("EST 1");
//          instancia.setIdinstanciaestacion(2);
//          VariableDTO varDTO = new VariableDTO();
//          varDTO.setIdvariable(2);
//          varDTO.setValorVariable("500");
//          varDTO.setTipoDatoDTO(new TipoDatoDTO(5));
//          
//          DocumentoDTO docDTO = new DocumentoDTO();
//          docDTO.setIddocumento(2);
//          TipoDocumentoDTO tipo = new TipoDocumentoDTO();
//          EstadoDocumentoDTO est = new EstadoDocumentoDTO();
//          est.setIdestadodocumento(3);
//          tipo.setIdTipoDocumento(2);
//          tipo.setEstadoDocumento(est);
//          docDTO.setIdtipodocumentoDTO(tipo);
//          
//          List<VariableDTO> lstVar = new ArrayList<VariableDTO>();
//          lstVar.add(varDTO);
//          List<DocumentoDTO> lstDoc = new ArrayList<DocumentoDTO>();
//          lstDoc.add(docDTO);
//          
//          prueba.setLstDocumentoDTO(lstDoc);
//          prueba.setLstVarDTO(lstVar);
//          prueba.setInstanciaDTO(instancia);
//          
//          
//           InstanciaEstacionDTO resp = executeStation(prueba);
          
          
          
          
//          
//           AplicacionClienteDTO apClienteDTO = new AplicacionClienteDTO();
//        
//        
//        UsuarioDTO usuarioDTO=new UsuarioDTO();
//        usuarioDTO.setIdusuario(1);
//        
//        EstadoInstanciaEstacionDTO instancia  = new EstadoInstanciaEstacionDTO();
//        instancia.setIdestadoinstanciaestacion(1);
//        
//        apClienteDTO.setUsuario(usuarioDTO);
//        apClienteDTO.setEstadoInstancia(instancia);
//        
//        getInstanceStationbyUser(apClienteDTO);
        
          
//        List<EstadoInstanciaEstacionDTO> lstEstadoInstanciaEstacion =getStateInstanceStation().getLstEstadoInstanciaEstacionDTO();  
//          
//        EstadoInstanciaEstacionDTO estado = null;
//          
//        for(EstadoInstanciaEstacionDTO e: lstEstadoInstanciaEstacion){
//            if(e.getNombre().equals(Constantes.Instancia_Estacion_INICIADA)){
//                estado = e;
//                break;
//            }
//        }
//  
//        AplicacionClienteDTO apClienteDTO = new AplicacionClienteDTO();
//        
//        
//        UsuarioDTO usuarioDTO=new UsuarioDTO();
//        usuarioDTO.setIdusuario(1);
//        
//        
//        
//        
//        apClienteDTO.setUsuario(usuarioDTO);
//        apClienteDTO.setEstadoInstancia(estado);
//        List<InstanciaEstacionDTO> lstInstanciaEstacionDTO = getInstanceStationbyUser(apClienteDTO).getLstInstanciaEstacionDTO();
//        
//        
//        ListInstanciaEstacionDTO res = new ListInstanciaEstacionDTO();
//        res.setLstInstanciaEstacionDTO(lstInstanciaEstacionDTO);
//      
//        int ak = 5 +5;
        
          
          
          
           return  null;
           
           
     
           
       }   
    
    //Obtener documentos por idexpediente

    public FormDTO getVariablesForm(Integer idEstacion) {
        return transactionalService.getVariablesForm(idEstacion);
    }

    public MapaSincronizadoDTO findMapaById(Integer id) {
       MapaSincronizadoDTO mapaDTO=new MapaSincronizadoDTO();
       MapaSincronizado result=null;
       try{
           result=crud.find(id, MapaSincronizado.class);
           if (result!=null){
               mapaDTO=ConvertBeanUtil.toMapaSincDTO(result, true);
           }
           LOG.info("Mapa obtenido correctamente");
       }catch(RuntimeException ex){
           LOG.error("Error al obtener mapa");
           throw ex;
       }
       return mapaDTO;
    }

 
    //obtener Historio input Variables
    
    
           
    public ListHistoricoVar getVarsHistoricInput( Integer codeInstanceStation){
    ListHistoricoVar lstResultBean = new ListHistoricoVar();
    InstanciaEstacionDTO instEstDTO = getInstanceStation(codeInstanceStation);
    Estacion estacion = transactionalService.getEstacion(instEstDTO.getInstanciaProceso().getIdproceso(), instEstDTO.getNombreEstacion());
    ArrayList<ArrayList<Regla>> lstReglas = MotorUtil.ordenarReglas(estacion.getReglaList());
    ArrayList<Regla> reglas = lstReglas.get(0);  
    try{
         for(Regla regla:reglas){  
          List<ParametroVariable> lstParVar = MotorUtil.getParametroVariable(regla);
              for(ParametroVariable parVar : lstParVar){
                          if(MotorUtil.esEntrada(parVar, regla) ){
                           
                              List<InstanciaEstacionXParametroVariable> list = transactionalService.getInstanciaEstXParametroVar(parVar.getIdparamentrovariable(),codeInstanceStation);
                             for(InstanciaEstacionXParametroVariable e: list){
                                for(HistoricoParametroVariable h:e.getHistoricoParametroVariableList()){
                                    HistoricParamVarDTO historicoDTO = new HistoricParamVarDTO();
                                    historicoDTO.setIdhistoricovariable(h.getIdhistoricovariable());
                                    historicoDTO.setFechamodificacion(h.getFechamodificacion());
                                    historicoDTO.setValorvariable(h.getValorvariable());
                                    historicoDTO.setNombreVariable(parVar.getIdestacionvariable().getIdvariable().getNombre());      
                                    lstResultBean.add(historicoDTO);
                                }
                             }                                
                            }
                 }
     }
    }catch(Exception Ex){
        lstResultBean = null;
    }
   
    return lstResultBean;
    }  
    
    
    
    public ListHistoricoDoc getDocsHistoricInput( Integer codeInstanceStation){
    ListHistoricoDoc lstResultBean = new ListHistoricoDoc();
    InstanciaEstacionDTO instEstDTO = getInstanceStation(codeInstanceStation);
    Estacion estacion = transactionalService.getEstacion(instEstDTO.getInstanciaProceso().getIdproceso(), instEstDTO.getNombreEstacion());
    ArrayList<ArrayList<Regla>> lstReglas = MotorUtil.ordenarReglas(estacion.getReglaList());
    ArrayList<Regla> reglas = lstReglas.get(0);  
    for(Regla regla:reglas){  
          List<ParametroDocumento> lstParDoc = MotorUtil.getParametroTipoDocumento(regla);
              for(ParametroDocumento parDoc : lstParDoc){
                          if(MotorUtil.esEntrada(parDoc, regla) ){
                              List<InstanciaEstacionXParametroDocumento> list = transactionalService.getInstanciaEstXParametroDoc(parDoc.getIdparametrodocumento() ,codeInstanceStation);
                             for(InstanciaEstacionXParametroDocumento e: parDoc.getInstanciaEstacionXParametroDocumentoList()){
                                for(HistoricoParametroDocumento h:e.getHistoricoParametroDocumentoList()){
                                    HistoricParamDocDTO historicoDTO = new HistoricParamDocDTO();
                                    historicoDTO.setIdhistoricodocumento(h.getIdhistoricodocumento());
                                    historicoDTO.setFechamodificacion(h.getFechamodificacion());
                                    historicoDTO.setNombreEstadodocumento(h.getIdestadodocumento().getNombre());
                                    historicoDTO.setNombreTipoDocumento(parDoc.getIdestaciontipodocumento().getIdtipodocumento().getNombre());                                    }
                             }                                
                            }
                 }
     }
    return lstResultBean;
    } 
    
    
    
    public ListHistoricoVar getVarsHistoricOuput( Integer codeInstanceStation){
    ListHistoricoVar lstResultBean = new ListHistoricoVar();
    InstanciaEstacionDTO instEstDTO = getInstanceStation(codeInstanceStation);
    Estacion estacion = transactionalService.getEstacion(instEstDTO.getInstanciaProceso().getIdproceso(), instEstDTO.getNombreEstacion());
    ArrayList<ArrayList<Regla>> lstReglas = MotorUtil.ordenarReglas(estacion.getReglaList());
    ArrayList<Regla> reglas = lstReglas.get(lstReglas.size() -1);  
    try{
         for(Regla regla:reglas){  
          List<ParametroVariable> lstParVar = MotorUtil.getParametroVariable(regla);
              for(ParametroVariable parVar : lstParVar){
                          if(MotorUtil.esSalida(parVar, regla) ){
                           
                              List<InstanciaEstacionXParametroVariable> list = transactionalService.getInstanciaEstXParametroVar(parVar.getIdparamentrovariable(),codeInstanceStation);
                             for(InstanciaEstacionXParametroVariable e: list){
                                for(HistoricoParametroVariable h:e.getHistoricoParametroVariableList()){
                                    HistoricParamVarDTO historicoDTO = new HistoricParamVarDTO();
                                    historicoDTO.setIdhistoricovariable(h.getIdhistoricovariable());
                                    historicoDTO.setFechamodificacion(h.getFechamodificacion());
                                    historicoDTO.setValorvariable(h.getValorvariable());
                                    historicoDTO.setNombreVariable(parVar.getIdestacionvariable().getIdvariable().getNombre());      
                                    lstResultBean.add(historicoDTO);
                                }
                             }                                
                            }
                 }
     }
    }catch(Exception Ex){
        lstResultBean = null;
    }
   
    return lstResultBean;
    }  
    public InstanciaProcesoDTO getInstanceProcessById(Integer idProcessInstance){
        InstanciaProcesoDTO bean = new InstanciaProcesoDTO();
        InstanciaProceso result = null;
        
        try{
            result = transactionalService.getInstanciaProcesoById(idProcessInstance);
            if(result != null){
                if(result.getIdinstanciaproceso() != null){
                    bean = ConvertBeanUtil.toInstanciaProcesoDTO(result);
                }else{
                    LOG.info("Instancia de estacion no encontrada");
                }

            }else{
                LOG.info("Codigo de instancia Estacion no encontrado");
            }  
         
        }catch(RuntimeException ex){
            LOG.error("Error: " +ex);
       }
        return bean;
    }

    
    public FormDTO getValoresParametros(Integer idInstanciaProceso) {
        FormDTO result=new FormDTO();
        try{
            result = transactionalService.getValoresParametros(idInstanciaProceso);
         
        }catch(RuntimeException ex){
            LOG.error("Error: " +ex);
       }
        return result;
    }

    public FormDTO getValoresEstacionAnterior(Integer idInstanciaProceso, Integer idInstanciaEstacionActual) {
        FormDTO result=new FormDTO();
        try{
            result = transactionalService.getValoresEstacionAnterior(idInstanciaProceso,idInstanciaEstacionActual);
         
        }catch(RuntimeException ex){
            LOG.error("Error: " +ex);
        }
        return result;
    }
    
    
    
      
    
    
   public ListHistoricoDoc getDocsHistoricOutput( Integer codeInstanceStation){
    ListHistoricoDoc lstResultBean = new ListHistoricoDoc();
    InstanciaEstacionDTO instEstDTO = getInstanceStation(codeInstanceStation);
    Estacion estacion = transactionalService.getEstacion(instEstDTO.getInstanciaProceso().getIdproceso(), instEstDTO.getNombreEstacion());
    ArrayList<ArrayList<Regla>> lstReglas = MotorUtil.ordenarReglas(estacion.getReglaList());
    ArrayList<Regla> reglas = lstReglas.get(0);  
    for(Regla regla:reglas){  
          List<ParametroDocumento> lstParDoc = MotorUtil.getParametroTipoDocumento(regla);
              for(ParametroDocumento parDoc : lstParDoc){
                          if(MotorUtil.esSalida(parDoc, regla) ){
                              List<InstanciaEstacionXParametroDocumento> list = transactionalService.getInstanciaEstXParametroDoc(parDoc.getIdparametrodocumento() ,codeInstanceStation);
                             for(InstanciaEstacionXParametroDocumento e: parDoc.getInstanciaEstacionXParametroDocumentoList()){
                                for(HistoricoParametroDocumento h:e.getHistoricoParametroDocumentoList()){
                                    HistoricParamDocDTO historicoDTO = new HistoricParamDocDTO();
                                    historicoDTO.setIdhistoricodocumento(h.getIdhistoricodocumento());
                                    historicoDTO.setFechamodificacion(h.getFechamodificacion());
                                    historicoDTO.setNombreEstadodocumento(h.getIdestadodocumento().getNombre());
                                    historicoDTO.setNombreTipoDocumento(parDoc.getIdestaciontipodocumento().getIdtipodocumento().getNombre());                                    }
                             }                                
                            }
                 }
     }
    return lstResultBean;
    } 
    
    
}
